home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / DistUpgrade / MetaRelease.py < prev    next >
Text File  |  2009-11-02  |  11KB  |  281 lines
  1. # MetaRelease.py 
  2. #  
  3. #  Copyright (c) 2004,2005 Canonical
  4. #  
  5. #  Author: Michael Vogt <michael.vogt@ubuntu.com>
  6. # 
  7. #  This program is free software; you can redistribute it and/or 
  8. #  modify it under the terms of the GNU General Public License as 
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. # 
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. # 
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21.  
  22. import apt_pkg
  23. import ConfigParser
  24. import httplib
  25. import rfc822
  26. import os
  27. import string
  28. import sys
  29. import time
  30. import thread
  31. import urllib2
  32.  
  33. from subprocess import Popen,PIPE
  34.  
  35. from utils import *
  36.  
  37. class Dist(object):
  38.     def __init__(self, name, version, date, supported):
  39.         self.name = name
  40.         self.version = version
  41.         self.date = date
  42.         self.supported = supported
  43.         self.releaseNotesURI = None
  44.         self.upgradeTool = None
  45.         self.upgradeToolSig = None
  46.  
  47. class MetaReleaseCore(object):
  48.     """
  49.     A MetaReleaseCore object astracts the list of released 
  50.     distributions. 
  51.     """
  52.  
  53.     DEBUG = "DEBUG_UPDATE_MANAGER" in os.environ
  54.  
  55.     # some constants
  56.     CONF = "/etc/update-manager/release-upgrades"
  57.     CONF_METARELEASE = "/etc/update-manager/meta-release"
  58.  
  59.     def __init__(self, 
  60.                  useDevelopmentRelease=False, 
  61.                  useProposed=False,
  62.                  forceLTS=False):
  63.         self._debug("MetaRelease.__init__() useDevel=%s useProposed=%s" % (useDevelopmentRelease, useProposed))
  64.         # information about the available dists
  65.         self.downloading = True
  66.         self.new_dist = None
  67.         self.current_dist_name = get_dist()
  68.         self.no_longer_supported = None
  69.  
  70.         # default (if the conf file is missing)
  71.         self.METARELEASE_URI = "http://changelogs.ubuntu.com/meta-release"
  72.         self.METARELEASE_URI_LTS = "http://changelogs.ubuntu.com/meta-release-lts"
  73.         self.METARELEASE_URI_UNSTABLE_POSTFIX = "-development"
  74.         self.METARELEASE_URI_PROPOSED_POSTFIX = "-development"
  75.  
  76.         # check the meta-release config first
  77.         parser = ConfigParser.ConfigParser()
  78.         if os.path.exists(self.CONF_METARELEASE):
  79.             try:
  80.                 parser.read(self.CONF_METARELEASE)
  81.             except ConfigParser.Error, e:
  82.                 sys.stderr.write("ERROR: failed to read '%s':\n%s" % (
  83.                         self.CONF_METARELEASE, e))
  84.                 return
  85.             # make changing the metarelease file and the location
  86.             # for the files easy
  87.             if parser.has_section("METARELEASE"):
  88.                 sec = "METARELEASE"
  89.                 for k in ["URI",
  90.                           "URI_LTS",
  91.                           "URI_UNSTABLE_POSTFIX",
  92.                           "URI_PROPOSED_POSTFIX"]:
  93.                     if parser.has_option(sec, k):
  94.                         self._debug("%s: %s " % (self.CONF_METARELEASE,
  95.                                                  parser.get(sec,k)))
  96.                         setattr(self, "%s_%s" % (sec, k), parser.get(sec, k))
  97.  
  98.         # check the config file first to figure if we want lts upgrades only
  99.         parser = ConfigParser.ConfigParser()
  100.         if os.path.exists(self.CONF):
  101.             try:
  102.                 parser.read(self.CONF)
  103.             except ConfigParser.Error, e:
  104.                 sys.stderr.write("ERROR: failed to read '%s':\n%s" % (
  105.                         self.CONF, e))
  106.                 return
  107.             # now check which specific url to use
  108.             if parser.has_option("DEFAULT","Prompt"):
  109.                 type = parser.get("DEFAULT","Prompt").lower()
  110.                 if (type == "never" or type == "no"):
  111.                     # nothing to do for this object
  112.                     # FIXME: what about no longer supported?
  113.                     self.downloading = False
  114.                     return
  115.                 elif type == "lts":
  116.                     self.METARELEASE_URI = self.METARELEASE_URI_LTS
  117.         # needed for the _tryUpgradeSelf() code in DistUpgradeController
  118.         if forceLTS:
  119.             self.METARELEASE_URI = self.METARELEASE_URI_LTS
  120.         # devel and proposed "just" change the postfix
  121.         if useDevelopmentRelease:
  122.             self.METARELEASE_URI += self.METARELEASE_URI_UNSTABLE_POSTFIX
  123.         elif useProposed:
  124.             self.METARELEASE_URI += self.METARELEASE_URI_PROPOSED_POSTFIX
  125.  
  126.         self._debug("metarelease-uri: %s" % self.METARELEASE_URI)
  127.         self.metarelease_information = None
  128.         if not self._buildMetaReleaseFile():
  129.             self._debug("_buildMetaReleaseFile failed")
  130.             return
  131.         # we start the download thread here and we have a timeout
  132.         t=thread.start_new_thread(self.download, ())
  133.         #t=thread.start_new_thread(self.check, ())
  134.  
  135.     def _buildMetaReleaseFile(self):
  136.         # build the metarelease_file name
  137.         self.METARELEASE_FILE = os.path.join("/var/lib/update-manager/",
  138.                                             os.path.basename(self.METARELEASE_URI))
  139.         # check if we can write to the global location, if not,
  140.         # write to homedir
  141.         try:
  142.             open(self.METARELEASE_FILE,"a")
  143.         except IOError, e:
  144.             path = os.path.expanduser("~/.update-manager-core/")
  145.             if not os.path.exists(path):
  146.         try:
  147.                     os.mkdir(path)
  148.         except OSError, e:
  149.                     sys.stderr.write("mkdir() failed: '%s'" % e)
  150.             return False
  151.             self.METARELEASE_FILE = os.path.join(path,os.path.basename(self.METARELEASE_URI))
  152.         # if it is empty, remove it to avoid I-M-S hits on empty file
  153.         try:
  154.             if os.path.getsize(self.METARELEASE_FILE) == 0:
  155.                 os.unlink(self.METARELEASE_FILE)
  156.         except Exception, e:
  157.             pass
  158.         return True
  159.  
  160.     def dist_no_longer_supported(self, dist):
  161.         """ virtual function that is called when the distro is no longer
  162.             supported
  163.         """
  164.         self.no_longer_supported = dist
  165.     def new_dist_available(self, dist):
  166.         """ virtual function that is called when a new distro release
  167.             is available
  168.         """
  169.         self.new_dist = dist
  170.  
  171.     def parse(self):
  172.         self._debug("MetaRelease.parse()")
  173.         current_dist_name = self.current_dist_name
  174.         self._debug("current dist name: '%s'" % current_dist_name)
  175.         current_dist = None
  176.         dists = []
  177.  
  178.         # parse the metarelease_information file
  179.         index_tag = apt_pkg.ParseTagFile(self.metarelease_information)
  180.         step_result = index_tag.Step()
  181.         while step_result:
  182.             if index_tag.Section.has_key("Dist"):
  183.                 name = index_tag.Section["Dist"]
  184.                 #print name
  185.                 rawdate = index_tag.Section["Date"]
  186.                 date = time.mktime(rfc822.parsedate(rawdate))
  187.                 supported = int(index_tag.Section["Supported"])
  188.                 version = index_tag.Section["Version"]
  189.                 # add the information to a new date object
  190.                 dist = Dist(name, version, date,supported)
  191.                 if index_tag.Section.has_key("ReleaseNotes"):
  192.                     dist.releaseNotesURI = index_tag.Section["ReleaseNotes"]
  193.                 if index_tag.Section.has_key("UpgradeTool"):
  194.                     dist.upgradeTool =  index_tag.Section["UpgradeTool"]
  195.                 if index_tag.Section.has_key("UpgradeToolSignature"):
  196.                     dist.upgradeToolSig =  index_tag.Section["UpgradeToolSignature"]
  197.                 dists.append(dist)
  198.                 if name == current_dist_name:
  199.                     current_dist = dist 
  200.             step_result = index_tag.Step()
  201.  
  202.         # first check if the current runing distro is in the meta-release
  203.         # information. if not, we assume that we run on something not
  204.         # supported and silently return
  205.         if current_dist is None:
  206.             #sys.stderr.write("current dist not found in meta-release file\n")
  207.             return False
  208.  
  209.         # then see what we can upgrade to (only upgrade to supported dists)
  210.         upgradable_to = ""
  211.         for dist in dists:
  212.             if dist.date > current_dist.date and dist.supported == True: 
  213.                 upgradable_to = dist
  214.                 self._debug("new dist: %s" % upgradable_to)
  215.                 break
  216.  
  217.         # only warn if unsupported and a new dist is available (because 
  218.         # the development version is also unsupported)
  219.         if upgradable_to != "" and not current_dist.supported:
  220.             self.dist_no_longer_supported(upgradable_to)
  221.         if upgradable_to != "":
  222.             self.new_dist_available(upgradable_to)
  223.  
  224.         # parsing done and sucessfully
  225.         return True
  226.  
  227.     # the network thread that tries to fetch the meta-index file
  228.     # can't touch the gui, runs as a thread
  229.     def download(self):
  230.         self._debug("MetaRelease.download()")
  231.         lastmodified = 0
  232.         req = urllib2.Request(self.METARELEASE_URI)
  233.         # make sure that we always get the latest file (#107716)
  234.         req.add_header("Cache-Control", "No-Cache")
  235.         req.add_header("Pragma", "no-cache")
  236.         if os.access(self.METARELEASE_FILE, os.W_OK):
  237.             lastmodified = os.stat(self.METARELEASE_FILE).st_mtime
  238.         if lastmodified > 0:
  239.             req.add_header("If-Modified-Since", time.asctime(time.gmtime(lastmodified)))
  240.         try:
  241.             uri=urllib2.urlopen(req)
  242.             # sometime there is a root owned meta-relase file
  243.             # there, try to remove it so that we get it
  244.             # with proper permissions
  245.             if (os.path.exists(self.METARELEASE_FILE) and
  246.                 not os.access(self.METARELEASE_FILE,os.W_OK)):
  247.                 try:
  248.                     os.unlink(self.METARELEASE_FILE)
  249.                 except OSError,e:
  250.                     print "Can't unlink '%s' (%s)" % (self.METARELEASE_FILE,e)
  251.             # we may get excpetion here on e.g. disk full
  252.             try:
  253.                 f=open(self.METARELEASE_FILE,"w+")
  254.                 for line in uri.readlines():
  255.                     f.write(line)
  256.                 f.flush()
  257.                 f.seek(0,0)
  258.                 self.metarelease_information=f
  259.             except IOError, e:
  260.                 pass
  261.             uri.close()
  262.         except (urllib2.URLError, httplib.BadStatusLine), e:
  263.             if os.path.exists(self.METARELEASE_FILE):
  264.                 self.metarelease_information=open(self.METARELEASE_FILE,"r")
  265.         # now check the information we have
  266.         if self.metarelease_information != None:
  267.             self._debug("have self.metarelease_information")
  268.             self.parse()
  269.         else:
  270.             self._debug("NO self.metarelease_information")
  271.         self.downloading = False
  272.  
  273.     def _debug(self, msg):
  274.         if self.DEBUG:
  275.             sys.stderr.write(msg+"\n")
  276.  
  277.  
  278. if __name__ == "__main__":
  279.     meta = MetaReleaseCore(False, False)
  280.     
  281.